{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/qiskit/providers/ibmq/ibmqfactory.py:192: UserWarning: Timestamps in IBMQ backend properties, jobs, and job results are all now in local time instead of UTC.\n",
      "  warnings.warn('Timestamps in IBMQ backend properties, jobs, and job results '\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "# Importing standard Qiskit libraries and configuring account\n",
    "from qiskit import QuantumCircuit, execute, Aer, IBMQ\n",
    "from qiskit.compiler import transpile, assemble\n",
    "from qiskit.tools.jupyter import *\n",
    "from qiskit.visualization import *\n",
    "# Loading your IBM Q account(s)\n",
    "provider = IBMQ.load_account()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 12 - Qiskit Aqua"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.aqua.components.initial_states import Custom\n",
    "init_state_0 = Custom(num_qubits=3, state='zero')\n",
    "init_state_uniform = Custom(num_qubits=3, state='uniform')\n",
    "init_state_random = Custom(num_qubits=3, state='random')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 140.777x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc0 = init_state_0.construct_circuit(mode='circuit')\n",
    "qc0.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200.977x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc1 = init_state_uniform.construct_circuit(mode='circuit')\n",
    "qc1.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1043.78x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc2 = init_state_random.construct_circuit(mode='circuit')\n",
    "qc2.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 261.032x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the quantum circuit\n",
    "num_qubits = 2\n",
    "qc = QuantumCircuit(num_qubits)\n",
    "qc.h(0)\n",
    "qc.cx(0,1)\n",
    "# Construct the Custom class based on the built quantum circuit\n",
    "q_component = Custom(num_qubits=num_qubits, circuit=qc)\n",
    "q_component.construct_circuit().draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import and create the PyTorchDiscriminator class\n",
    "from qiskit.aqua.components.neural_networks import PyTorchDiscriminator\n",
    "# Set the number data input and output dimension to 2.\n",
    "py_torch_disc = PyTorchDiscriminator(n_features = 2, n_out=2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the discriminator model, implements the torch.load(dir) \n",
    "discriminator_model = '/discriminator_model_directory'\n",
    "py_torch_disc.load_model(discriminator_model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters are defined in the Qiskit API as follows: \n",
    "###\n",
    "# data (tuple) – real_batch: torch.Tensor, Training data batch. generated_batch: numpy array, Generated data batch.\n",
    "# weights (tuple) – real problem, generated problem\n",
    "# penalty (bool) – Indicate whether or not penalty function is applied to the loss function.\n",
    "# quantum_instance (QuantumInstance) – Quantum Instance (depreciated)\n",
    "# shots (int) – Number of shots for hardware or qasm execution. Not used for classical network (only quantum ones)\n",
    "###\n",
    "result_dict = PyTorchDiscriminator.train(data, weights, penalty, quantum_instance=quantum_instance, shots=None)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x7efdb975e350>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import the CircuitStateFn class\n",
    "from qiskit.aqua.operators.state_fns import CircuitStateFn\n",
    "# Create the quantum circuit\n",
    "qc = QuantumCircuit(2)\n",
    "qc.h(0)\n",
    "qc.cx(0,1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CircuitStateFn(\n",
      "     ┌───┐     \n",
      "q_0: ┤ H ├──■──\n",
      "     └───┘┌─┴─┐\n",
      "q_1: ─────┤ X ├\n",
      "          └───┘\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Create the CircuitStateFn class with the quantum circuit\n",
    "csf = CircuitStateFn(primitive=qc, coeff=1, is_measurement=False)\n",
    "print(csf)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Create a second quantum circuit with same width and operators\n",
    "qc2 = QuantumCircuit(2)\n",
    "qc2.h(0)\n",
    "qc2.cx(0,1)\n",
    "\n",
    "# Create the second circuit state function\n",
    "csf2 = CircuitStateFn(primitive=qc2, coeff=1, is_measurement=False)\n",
    "\n",
    "# Compare both circuit state functions using the equals operator\n",
    "print(csf.equals(csf2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CircuitStateFn(\n",
      "     ┌───┐     \n",
      "q_0: ┤ H ├──■──\n",
      "     └───┘┌─┴─┐\n",
      "q_1: ─────┤ X ├\n",
      "          └───┘\n",
      ") * 2\n"
     ]
    }
   ],
   "source": [
    "# Add the two circuit state functions together\n",
    "added_csf = csf.add(csf2)\n",
    "print(added_csf)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SummedOp([\n",
      "  CircuitStateFn(\n",
      "       ┌───┐     \n",
      "  q_0: ┤ H ├──■──\n",
      "       └───┘┌─┴─┐\n",
      "  q_1: ─────┤ X ├\n",
      "            └───┘\n",
      "  ) * 2,\n",
      "  CircuitStateFn(\n",
      "       ┌───┐┌───┐\n",
      "  q_0: ┤ H ├┤ X ├\n",
      "       └───┘└─┬─┘\n",
      "  q_1: ───────■──\n",
      "                 \n",
      "  )\n",
      "])\n"
     ]
    }
   ],
   "source": [
    "# Create a quantum circuit\n",
    "qc3 = QuantumCircuit(2) \n",
    "qc3.h(0)\n",
    "qc3.cx(1,0) \n",
    "# Create a circuit state function from the quantum circuit\n",
    "csf3 = CircuitStateFn(primitive=qc3, coeff=1, is_measurement=False)\n",
    "print(added_csf.add(csf3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary result:  110.\n"
     ]
    }
   ],
   "source": [
    "# Import the utils module\n",
    "from qiskit.aqua import utils \n",
    "# convert the number 6 from decimal to binary\n",
    "binary_value = utils.decimal_to_binary(6, max_num_digits=0)\n",
    "print('Binary result: ', binary_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Unitary result: \n",
      " [[ 0.62908478+0.34714688j -0.2728722 -0.46236552j -0.06999293+0.43657905j]\n",
      " [ 0.62861687+0.17592649j  0.22322343+0.20435486j -0.0264057 -0.69397683j]\n",
      " [ 0.23669704+0.04008236j  0.56588394+0.54767203j  0.03572391+0.56650016j]]\n"
     ]
    }
   ],
   "source": [
    "#Random Unitary matrix\n",
    "random_unitary = utils.random_unitary(N=3)\n",
    "print('Random Unitary result: \\n', random_unitary)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an array of random quantum circuits\n",
    "from qiskit.circuit.random import random_circuit\n",
    "quantum_circuits = []\n",
    "# Append a group of random circuits\n",
    "for x in range(2):\n",
    "    quantum_circuits.append(random_circuit(3, 5, measure=True))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting 2 circuits.\n",
      "============================================================================\n",
      "0-th circuit: 3 qubits, 3 classical bits and 11 operations with depth 6\n",
      "op_counts: OrderedDict([('measure', 3), ('cswap', 2), ('cz', 1), ('ry', 1), ('id', 1), ('t', 1), ('h', 1), ('ccx', 1)])\n",
      "1-th circuit: 3 qubits, 3 classical bits and 9 operations with depth 6\n",
      "op_counts: OrderedDict([('measure', 3), ('cswap', 2), ('ccx', 2), ('crz', 1), ('u1', 1)])\n",
      "Average: 3.00 qubits, 3.00 classical bits and 10.00 operations with depth 6.00\n",
      "============================================================================\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Obtain and print a summary of all the quantum circuits\n",
    "circuits_summary = utils.summarize_circuits(quantum_circuits)\n",
    "print(circuits_summary)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full coupling map:  [[0, 1], [0, 2], [0, 3], [0, 4], [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n"
     ]
    }
   ],
   "source": [
    "# Fully entangled coupling map\n",
    "full_coupling_map = utils.get_entangler_map(map_type=\"full\", num_qubits=5)\n",
    "print('Full coupling map: ', full_coupling_map) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full coupling map:  [[0, 1], [1, 2], [2, 3], [3, 4]]\n"
     ]
    }
   ],
   "source": [
    "# Linearly entangled coupling map\n",
    "lin_coupling_map = utils.get_entangler_map(map_type=\"linear\", num_qubits=5)\n",
    "print('Full coupling map: ', lin_coupling_map)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1], [0, 2], [0, 3], [0, 4], [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n"
     ]
    }
   ],
   "source": [
    "# Validate entangled coupling maps\n",
    "result = utils.validate_entangler_map(entangler_map=full_coupling_map, num_qubits=5, allow_double_entanglement=True)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8.66025404e-01  3.92523115e-17]\n",
      " [-8.66025404e-01  3.92523115e-17]]\n"
     ]
    }
   ],
   "source": [
    "# Import NumPy to create the array\n",
    "import numpy as np\n",
    "\n",
    "# Generate a 2x3 (NxD) array\n",
    "dim_map = np.array( [[ 0,1,0], [ 1,0,1]])\n",
    "# Reduce the D from 3 to 2, resulting in a 2x2 dimensional array\n",
    "reduced_dim = utils.reduce_dim_to_via_pca(x=dim_map, dim=2)\n",
    "print(reduced_dim)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the necessary modules and classes\n",
    "from qiskit import BasicAer\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from qiskit.aqua.algorithms import Grover, DeutschJozsa, BernsteinVazirani, Simon\n",
    "from qiskit.aqua.components.oracles import LogicalExpressionOracle, TruthTableOracle, CustomCircuitOracle\n",
    "\n",
    "# State the SAT problem into a logical expression\n",
    "# A = Sophia, B = Angelina, C = Leo, D = Lex\n",
    "expression = '((A ^ B) & (C & D) & ~(A & C))'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an Oracle based on the Logical Expression\n",
    "oracle = LogicalExpressionOracle(expression)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 320.941x445.48 with 1 Axes>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Construct the circuit from the oracle\n",
    "quantum_circuit = oracle.construct_circuit()\n",
    "quantum_circuit.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a quantum instance from a simulator\n",
    "quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=1024)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Grover algorithm with the Logical Expression Oracle\n",
    "grover = Grover(oracle)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top result: 1110\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the Grover algorithm \n",
    "result = grover.run(quantum_instance)\n",
    "\n",
    "# Print the top measured result\n",
    "print('Top result:', result['top_measurement'])\n",
    "# Plot all measured results\n",
    "plot_histogram(result['measurement'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Truth Table expression for constant\n",
    "truth_table = '1111'\n",
    "\n",
    "# Create the Truth Table Oracle from the expression\n",
    "constant_oracle = TruthTableOracle(truth_table)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1103.25x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create Deutsch-Jozsa algorithm\n",
    "dj = DeutschJozsa(oracle=constant_oracle, quantum_instance=quantum_instance)\n",
    "# Construct the circuit and draw the result\n",
    "dj_circuit = dj.construct_circuit(measurement=True)\n",
    "dj_circuit.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'measurement': {'00': 1024}, 'result': 'constant'}\n"
     ]
    }
   ],
   "source": [
    "# Run the algorithm on the quantum instance\n",
    "results = dj.run(quantum_instance)\n",
    "# Print the results that determines constant or balanced\n",
    "print(results)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the expression for secret value s: \n",
    "# (This ties x1=01, x2=10 XOR with s=11)\n",
    "s = '0110'\n",
    "\n",
    "# Create the Truth Table Oracle from the expression\n",
    "oracle_simon = TruthTableOracle(s) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAADWCAYAAABsW94fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAkCklEQVR4nO3de1wVdf4/8Necwy0ClbygiJiKJJCIpmxqCgZmZZumePlutZWVl3S/6eYqmquyti6sF/y1ptjFHl9t0wLzsruW6SYotaWkpCJ4Cy+AecML3gA58/vjLCgC53BkznxmzryejwePhTlz5ryYR/vm5cycOZIsyzKIiIiISLNMogMQERERkW0sbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHEsbEREREQax8JGREREpHFuogOQ/uXn59tdZ+nSpZg0aZLNdbp06aJUJCLSESVmCOcHuToeYSNVvPfee6IjEJGOcYaQ0bGwEREREWkcCxsRERGRxrGwkSrS09NFRyAiHeMMIaNjYSMiIiLSOBY2UkV8fLzoCESkY5whZHS8rYcAX2QDRRfVf922fsCwnuq/Lrm+tw4dxE+lpUJeu5uvLxY9FCbktUXgvlaPqFkNNG5eT548GTk5OYrmaYjIyEgsWbJE9dc1ChY2AYouAsfOik5BpJyfSkux42KJ6BiGwH2tHr3O6pycHGRmZoqOQQrjKVFSxcSJE0VHICId4wwho2NhI1XY+5QDIiJbOEPI6FjYSBX9+/cXHYGIdIwzhIyOhY1Uce7cOdERiEjHOEPI6FjYiIiIiDSOhY1UERZmnFsBEJHyOEPI6FjYSBXr1q0THYGIdIwzRFvc3d1FRzAcFjZSxezZs0VHICId4wxxDh8fH8THxyMpKQkbN27E119/jfXr12PevHl49tln4eXlVes5TZs2RVZWFiZPnqx+YAPTbGGLjY3FI488Umv5hQsX4Ofnh4SEBAGp6F6lpaWJjmAIsiw6gXFwX6uLM0RZ/v7+WLp0KYqLi5GWlobp06fj2WefxcCBAzF06FDMmjULGzduRGFhIZKSktC0aVMA1rK2detWREVFYdKkSfD29hb8mxiHZgtbREQE8vLyYLFYaixPTEyEh4cHZs6cKSiZ+tLficGuDe80eDkZy61y4EQ28O2HwL8XA98sAfb/E7h8WnSy+skVFagYPwmVKz6osbxy/QZUvPAS5KtXBSWzrfwG8PN/gJ0rgH8vAra/CxzcAlzV8BsY9bqv9Ugvs3rUqFHIzc3FxIkT4evri6ysLCQmJmL48OEYNGgQRo4cifnz5+PHH39E8+bNMX36dBw4cADPPfcctm7dil69euHYsWMYMGAArl+/LvrXMQzNfjRVREQEbty4gZ9//hnBwcEAgCNHjiA1NRXvvvsumjRpIjghkXgVN4AfPwOunr+9zHILOHMIOJMPhA0CArqKy1cfyd0dbgl/wK3fTYYU1Qum7pGQCwpgWfl/MP/5T5B8fERHrOXmFSB7rfV/q1SWA8X7gdO5QMQQoGUncfnqo8d9Tc4zbdo0JCcnAwC2bNmCqVOn4sCBA7XWS0tLw9tvv42oqCgsWbIEvXv3xrp16yBJUnVZO3XqlNrxDU3TR9gAIDc3t3rZ9OnT0blzZ7z++usAgOPHjyM6OhohISHo2rUrdu7cKSQr2cfPtXOOg1/XLGvV/nu67uAWoFSjR3+kB9vDNOYlVC5MgVxSgltJC2Aa8muYIjTYMAHs+wdws57PXJctwL5N9T8umt72dV04Qxrv5ZdfRnJyMiwWC373u9/hySefrLOs3WnXrl0YPHgwioqKIEkSZFnGn/70J5Y1ATRb2MLDw2E2m6sLW1ZWFtavX4+FCxfCbDYDAMaNG4dRo0bh8OHDWLFiBUaPHo3y8nKRsakedxZvUsaNy8C5I/bXK9zr/Cz3yjR0CKSgdrg1biJgNsP00ouiI9Xp8mngymlUF+G6yJVA0T7VIjlML/u6PpwhjdO+fXu8++67AIDx48dj6dKlDXpe06ZNsWXLFrRt2xYlJSWQJAlJSUnw8/NzZlyqg2ZPiXp5eSEkJKS6/U+dOhUDBw7EU089BQA4f/48srKysGnTJgBAnz59EBAQgO3bt2PQoEGKZJAkSZHt3G3429sRGBrj0HN2bfwzfty8sMayiptXEfRwXIO3kZmZgf99YoBDr9sQU6ZMsbtOSkqK3fVSUlKUimQIT0W9it+P+NDuej/tLELYoECnZjEvSIKpW4TDz5MkCVJEV8g/7oFp9EhI93CrgIyMDEi9HnX4eY54Pm4WXh40z+Y6sizjq892Y9Jjv3JqFlfc10rMEGfMD1GzGlB+Xv/1r3+Fr68v0tPT8cEHH9h/Am6/waDqmrXY2FisXr0a/fr1w9y5c/Hmm2/elTnTaX83XZXswLuXNFvYAOtp0dzcXKxduxa7d+9GTk5O9WMnT56Ev78/PD09q5d16NABJ06cEJDU+aKGvI2oobNqLEt/J0ZMGNIEN7NHg9Zzb+B6IsgFBbB8uhamUSNg+eRTmPr1hdSqlehYtbiZPSDLss0/RpIkwd3Ns97HRdPLvtY7Lc7qgIAADBs2DBUVFbVKVn3uLmtV16xNmjQJP/30E15++WXMnDkT165dc3J6qqL5wrZhwwbMmDEDY8aMQdeu6l5v4UjzdcTftgLHzjpl0zZFR8cg/R3lf6f8/Hy766SkpGDs2LE211m8eLFSkQzh4inrGw5skoAHQ1s67b/lKnHZP2DHxRKHniOXV1ivpRo2FOZXXoJ88SIqFyyGOXk+JFPDr9aIiYnBNif/fr/kAwf+aWclCegT2w3yYu5rRykxQ5wxP0TNaqBx8zomJqbGNX+jR4+Gm5sb0tLSUFxcbPf59ZU1ANi3bx+ysrLw2GOP4dlnn8WaNWvuyByNjIyMe8pM9mn2GjYA6NatG8rKynD+/HnMm1fzdERQUBDOnDmDsrKy6mUFBQVo37692jGpARITE0VHcDnNAgFvPwC2zkDIQGCkSoEcZFn5MSQ3N5hefB4AYH5jPORfzsCybr3gZLW1Cgbca98/tCbua6fiDLl3UVFRAIAvv/zS7rq2ylqVqu306tVL+bBUL00XtsGDB0OWZZSWlqJ169Y1HmvRogX69u2Ljz76CADw3XffoaioCAMGKH+NFjXeyJEjRUdwOZIEhD5h/d/6SluLjkCrzqrGahDL3hxYNn8Fc8I0SG7WA/2StzfM06fCsuoTyAUFghPWZHIDujxhe52ArkDTAHXyOEJv+7o+nCH3rurs1N69tt+B1JCydud2qu7mQOrQ9ClRe1JTU/Hyyy9jyZIl8PDwwJo1a+Dhod3rde5V/KwMh5ZrUWhoKPLy8kTHcDl+7YAeI4HD3wCld5y6MbkBgd2A4P6ApMF/lpm6R8K06Yvayx8Oh+kf2jzq4x8CmJ4DjmQA1y/eXu7mCQQ9AnTo/d/yrDF63Nd10cMM0eqsXr9+PX744QcUFhbaXG/16tV2yxoAHD58GCtXrmzQqWxSjq4LW8eOHbFjxw7RMYiE8gsEfvVb4MoZYNdq67L+bwBurvdvF+FadrIetbx8Gsj+1Lqs33jAzM/BJg2bNWuW/ZVgvddp8+bNMXr0aJv3WTt27BheffVVpeJRA+m6sBHRbU38b3/PsuY8kgQ0u+PUJ8sauYq8vDz07dtXdAyqhwZPlpAriomJER2BiHSMM4SMjoWNVLF8+XLREYhIxzhDyOhY2EgVEyZMEB2BiHSMM4SMjoWNVMGbKRJRY3CGkNGxsBERERFpHAsbERERkcaxsJEqtH7DSyLSNs4QMjoWNlLF559/LjoCEekYZwgZHW+cK0BbP2O9LgDMmTOHnwXowrr5+hrytUUw6r4WMUNEzszGvHZkZKTDz/n55GkAQMegNjW+d/brUsOxsAkwrKfoBETKWvRQmOgIhsF9rR69zuolS5Y4/JyE5PcBAEnTx9b4nrSDp0SJiIiINI6FjVSxbNky0RGISMc4Q8joWNhIFeHh4aIjEJGOcYaQ0bGwkSqio6NFRyAiHeMMIaNjYSMiIiLSOBY2IiIiIo1jYSNV9OrVS3QEItIxzhAyOhY2UsXu3btFRyAiHeMMIaNjYSMiIiLSOBY2IiIiIo1jYSNVpKeni45ARDrGGUJGx8JGREREpHEsbKSK+Ph40RGISMc4Q8jo3EQHMKIvsoGii+q/bls/YFhP9V9XpLcOHcRPpaWqv243X18seihM9dcVRdR+Boy3r0k9omY1YLx5PXnyZOTk5Ah57cjISCxZskTIazuChU2AoovAsbOiUxjDT6Wl2HGxRHQMl8f9TK6Is1o9OTk5yMzMFB1D03hKlFQxceJE0RGISMc4Q8joWNhIFZMmTRIdgYh0jDOEjI6FjVTRv39/0RGISMc4Q8joWNhIFefOnRMdgYh0jDOEjI6FjYiIiEjjWNhIFWFhvO0CEd07zhAyOt7Wg1Sxbt060RGISMc4Q+hu7u7uCAsLQ8uWLSHLMgoLC3H48GHIslzn+gEBARg0aBA+/vhjlZMqg0fYSBWzZ88WHYGIdIwzhADA09MTzz//PDIzM1FaWoqcnBxs3boV27ZtQ35+Pi5fvoz169fjiSeegCRJ1c8LCAjA9u3bsXLlSrzwwgsCf4N7p9nCFhsbi0ceeaTW8gsXLsDPzw8JCQkCUtG9SktLEx3Bpd0qB4r23f75yhlxWVxdxQ3g1N7bP1+7IC6LkXCGUFxcHA4dOoRPPvkE/fv3h6enJw4dOoRt27bhm2++walTp+Dr64uhQ4diy5Yt+P777xEaGlpd1kJCQrBnzx7861//Ev2r3BPNFraIiAjk5eXBYrHUWJ6YmAgPDw/MnDlTUDL1pb8Tg10b3mnwcro3ckUFKsZPQuWKD2osr1y/ARUvvAT56lVByWwr/AnYuRzI+/r2sl2rgew1QNk1cbls0eO+lmWg4HtgRypw6N+3l//nYyBnPXCrTFw20gbOaueZP38+tm7divbt2+PAgQN4/fXX0axZM3Tp0gUDBw5EbGwsgoKC0LZtW8ycORPFxcWIiorC3r17kZ2dXV3W4uLicPGioM8bayRNF7YbN27g559/rl525MgRpKamIjExEU2aNBGYjlyR5O4Ot4Q/wPLPzbDszQEAyAUFsKz8P5inTYXk4yM2YB2K9wP5W4HKitqPXSoG9nxuPfqmNXrc18d3AceyALmy9mPnjwF7vwDu+vclESlgwYIFmDFjBioqKjBjxgxERkbiww8/xOXLl2utW1xcjL/85S8IDQ3Fp59+Ck9PT7Rp0wbHjx/XdVkDNF7YACA3N7d62fTp09G5c2e8/vrrAKzXNISEhMBkMiE9PV1ITmoYvXxGnPRge5jGvITKhSmQS0pwK2kBTEN+DVNEV9HRarFUAkd22FhBtp6u++WgapEcoqd9XXETKPjO9jqXi6zFjZxDLzOElDV06FBMnToV5eXleO6555CUlITKyjr+1XQXHx8f9OzZs/rn1q1bo1WrVs6M6nSaLWzh4eEwm83VhS0rKwvr16/HwoULYTabAQBPPvkkvvrqK94BWwfuLN5aZxo6BFJQO9waNxEwm2F66UXRkep0vsB6PZU9hfvsryOKXvb1mXxrQbZJsh7xJOfQ0wwhZTRr1gypqakAgN///vcNvvbs7mvW/v73v8PLywsrV650Zlyn0+xtPby8vBASEoIDBw4AAKZOnYqBAwfiqaeeql6nT58+Ts1w5ztMlDT87e0IDI1x6Dm7Nv4ZP25eWGNZxc2rCHo4rsHbyMzMwP8+McCh122IKVOm2F0nJSXF7nopKSlKRapmXpAEU7cIh54jSRKkiK6Qf9wD0+iRkNzdHX7djIwMSL0edfh5jhjSZyImPbfU7nrFBRcgSS2cmuVe9jOgn339ypPv4H8en2l7JsjA7u/2o/twx/eD0SkxQ5wxP0TNasB587o+05NWALD+f/LO70UaM2YM/P39kZWVhWXLljXoOXeXtbi4OFgsFsTGxqJPnz6Ijo6udbQ2MzNT2O9a3y1I6qLZwgZYT4vm5uZi7dq12L17N3JyckRHEiZqyNuIGjqrxrL0d2LEhHFxckEBLJ+uhWnUCFg++RSmfn0hafBQ+rWbta/fuJssyw1aTxQ97Wt7A91iqcTV65fUCUSaxVmtnAkTJgAAkpOTG1Rs6iprVdespaamYu7cuZgwYYJuT69rvrBt2LABM2bMwJgxY9C1q7rXtjjSfB3xt63AsbNO2bRN0dExSH9H+d8pPz/f7jopKSkYO3aszXUWL16sVKRqcdk/YMfFkgavL5dXWK+lGjYU5ldegnzxIioXLIY5eT4kU8OvIIiJicE2J/33U6XipvXdobZO1UmShN6DO0L+i3OzOLqfAX3t6+uXgO8+tL2OyWRG/Ov9MGWZc7O4IiVmiDPmh6hZDThvXtcnIfl9ANa/e3d+r5aYmJgaRSooKAjBwcG4cOECNm/ebPf5tsoaAKxatQpz585FbGxsredGR0cjIyNDkd/DmTR7DRsAdOvWDWVlZTh//jzmzZsnOg41QmJiougIDWJZ+TEkNzeYXnweAGB+YzzkX87Asm694GS1uXsBgZE2VpAAszsQ2E2tRI7R0772bgb4P2RjBQnw8Aba8NOTnEYvM4SU0aNHDwBAdnZ2rdt73c1eWQOAgoICnD9/Hi1atEBQUJDTcjuTpgvb4MGDIcsySktL0bp1a9FxqBFGjhwpOoJdlr05sGz+CuaEaZDcrAefJW9vmKdPhWXVJ5ALCgQnrC24P9CqqkjcdcbO7A50Hw54+aoeyy497uuwQYBf1Zy/a1973Af0GAG4eaoeyzD0MENIOW3btgUAHDtm+63XDSlrVY4ePVr9HD3S9ClRe/74xz/i448/xrlz57B//35MnjwZmZmZ6NSpk+hoioqfleHQci0KDQ1FXl6e6Bg2mbpHwrTpi9rLHw6H6R/aO+oDACYz0PUZ4FKk9ZMOfvnvLu4cDQQ8DLjfJzRevfS4r80e1lJ2oQAo2g+cO2Jd3iUOaB0GuHmIzefq9DBDXGFWa0VqaipWr15t9+hakyZN0LRp0wbdFPfJJ59EZWUlrl3T6B3F7dB1YZs3bx5PlZLhSRLg1876VVXY2vcSm8lVSRLQoqP1a9t/3who87Q0Ed2TyspKXLlyxe56+fn5iI6OxtmzZ+3eFLeuG+3qia4LGxERERnboUOHREdQhaavYSPXERMTIzoCEekYZwgZHQsbqWL58uWiIxCRjnGGkNGxsJEqqm6ASER0LzhDyOhY2EgVergpIRFpF2cIGR0LGxEREZHGsbARERERaRwLG6lC6ze8JCJt4wwho+N92ARo62es1wWAzz//XMhHy3TzFfO5TKJeVxSRv6/R9rVRiZghImemyNcWITIy0uHn/HzyNACgY1CbGt+r8doisLAJMKyn6ATqmzNnjpDCtughfhq3GrifydlEzBAjzmpRlixZ4vBzEpLfBwAkTR9b43tXxVOiRERERBrHwkZERESkcSxspIply5aJjkBEOsYZQkbHwkaqCA8PFx2BiHSMM4SMjoWNVBEdHS06AhHpGGcIGR0LGxEREZHGsbCRKnr16iU6AhHpGGcIGR0LG6li9+7doiMQkY5xhpDRsbARERERaRwLGxEREZHGsbCRKtLT00VHICId4wwho2NhIyIiItI4FjZSRXx8vOgIRKRjnCFkdCxsRERERBrHwkZERESkcSxspIqJEyeKjkBEOsYZQkbHwkaqmDRpkugIRKRjnCFkdCxspIr+/fuLjuDSKm8BV87c/vlmKSDL4vK4ssoK4Movt38uvyYui5FwhpDRuYkOQMZw7tw50RFczq1y4JeDQPEBoPQsIFtuP5a1AvDwBlp0AgIjgSb+wmK6hIobQHEucDoXuHoewB1leMdywNMXaBVs3df3NxeV0rVxhpDRsbAR6YwsA2fygfx/A7du1r9e+XWgeL/1q2VnoEsc4Hm/ejldgSwDhTnA0R3WI2v1KSsFTu21fgU8DIQMANw8VYtJRAbAwkaqCAsLEx3BJVgqgYNfAb/kOfa8c0eAS6eAbkOBZoFOieZybpUD+zcBF4479rziA8CFE0D3YYBPS6dEMyTOEDI6XsNGqli3bp3oCLonW4D9/3S8rFWpuAnsSQcuFSubyxVVVgA5Xzhe1qqUlQI/fgZcu6BoLEPjDCGjY2EjVcyePVt0BN07kW09UmZL3FTrV30st6xHjSpsnEol4GgWcKnQ9jr29nXFTWDfJus+p8bjDCGj02xhk2UZqamp6NGjB7y9vREUFITJkyfj6tWroqPRPUhLSxMdQdeulQDHvlVmW2VXgSOZymzLFV0qBk79qMy2rl0ACr5XZltGxxlCRqfJa9gsFgteeOEFbNq0CW+//TYeffRRHDp0CAkJCTh9+jQ+++wz0RGJVHUyG5Arldte8QGgYx/Ay1e5bbqK4z8ou72Te4D2UYCbh7LbJSJj0WRhe++99/DZZ58hIyMD/fr1AwAMGDAA586dw+zZs7FixQo0a9ZMbEgildwqA04fVHijMlC0D+jUV+Ht6tzNK8D5Y8pus7Lcet1hYDdlt0tExqLJU6KLFi3CM888U13WqgQHBwMACgsLcfz4cURHRyMkJARdu3bFzp07RUSlBsrM5Dm4e3X5tHOug7p4Uvlt6l2Jk/ZJyQnnbNdIOEPI6DRX2I4dO4YTJ05g8ODBtR47deoUACAgIADjxo3DqFGjcPjwYaxYsQKjR49GeXm52nGpgXJzc0VH0K07P8FASXffbJeAUmftaydt10g4Q8joNHdKtOpu1gEBAbUe27p1KyIjI2GxWJCVlYVNmzYBAPr06YOAgABs374dgwYNUiyLJEmKbcuVTZkyxe46KSkpdtdLSUlRKpJLmTT0bxjSt+bnKNp6d6Ktx7ctvP19ZQXQxMcPV29calxAFzL7t+no13V4jWVK7OvL529Cku5rZDrXpcQM4fxonOlJKwBY/+7d+b2W6THz3WQHPkNQc4XtwQcfBAAcPXq0xvLNmzdj27ZtWLVqFU6ePAl/f394et6+lXiHDh1w4gTPO5DrceYAkqCv4eZsTtsfOvsjQkTao7nC1rp1azzzzDOYP38+mjRpgo4dO2LHjh1ITk7GuHHj8OKLL2LPnj2qZHGk+RpZfn6+3XVSUlIwduxYm+ssXrxYqUgu5di3QMF/ai678+jNnaqO9tT3+J0kM3CptAQmc+PyuZK8r61vxriTEvvat5kn54kNSswQzo/GSUh+H4D1796d32uZHjM3huYKGwCsWrUK06ZNw6xZs3D58mWEhYVh6dKleOWVVwAAQUFBOHPmDMrKyqqPshUUFKB9+/YiY5MNiYmJoiPolrM+uN23BVjW7uLrrH3tpO0aCWcIGZ0mC5ufnx8++OCDeh9v0aIF+vbti48++ghvvPEGvvvuOxQVFWHAgAEqpiRHjBw5UnQE3WoaAEgm5d8gwM8Ura1ZW31t10g4Q8joNPcu0YZKTU3F2rVrERISgrFjx2LNmjXw8OCdKbUqNDRUdATd8vAGWgYrv922EcpvU+98WihfriQzEBCu7DaNiDOEjE6TR9gaouraNiIjaN8TOHtYue216Ajc31y57bmSoF7ApSLlthcQDnjcr9z2iMiYdHuEjchImgYA7Xoosy2zB9AlTpltuaJWwUCrEGW25ekDBPdXZltEZGy6PcJG+hITEyM6gu4F9wMuFwNXfql/nYa8YzFsEODVRLlcrqhLHHD1HHD9Yv3r2NvXkhkIfxpw91I2m1FxhpDR8QgbqWL58uWiI+ie2R3oHm892nYvJJO1QPg/pGwuV+ThDfQYee+njU1uQORQ4IEgRWMZGmcIGR0LG6liwoQJoiO4BHcv4JFRQIfe1gLWUD4tgagXgDZhzsvmarx8gajngXbdHXtes0Dg0ZeA5h2ck8uoOEPI6HhKlFSRkZEhOoLLMJmBTn2B1qFA4U/A6QPArbK6123aFmgXab0mi/dcc5zZA3goFgjoChTmAL/kWT/Sqy4PPAgERgItO/GDDZyBM4SMjoWNSKfufwB4aAAQEm291qr0rLW4SSbgvmaAbyteP6UU31ZA6BPW8natBLh61lrcJBPg/YD1cTfeVYiInIiFjUjnJJP1WivepsP5TGbAt6X1i4hITbyGjVSRl5cnOgIR6RhnCBkdCxup4vPPPxcdgYh0jDOEjI6FjVQxZ84c0RGISMc4Q8joWNiIiIiINI6FjYiIiEjjWNhIFcuWLRMdgYh0jDOEjI6FjVQRHh4uOgIR6RhnCBkdCxupIjo6WnQEItIxzhAyOhY2IiIiIo1jYSMiIiLSOH40FTValy5d7K4zZ86cBq1HRMbDGUJkH4+wkSrmzp0rOgIR6RhnCBkdCxsRERGRxrGwEREREWkcCxsRERGRxrGwEREREWkcCxsRERGRxrGwEREREWkcC5uTnTp1CrGxsQgNDUV4eDhmzJghOhIREZFiMjIyEB4ejuDgYLz22muorKwUHcmuN998E4GBgXBz08/taFnYnMzNzQ3JycnIy8vD3r17kZWVhY0bN4qORURE1GgWiwWvvfYa0tLScPToUVy5cgWffPKJ6Fh2jRgxAtnZ2aJjOISFzcnatGmDnj17AgA8PDzQvXt3nDx5UnAqIiKixtu9ezcCAgIQFhYGAHj11Vexbt06wanse+yxx9C6dWvRMRzCwqaikpISbNiwAQMHDhQdhYiIqNEKCwvRrl276p+DgoJw6tQpgYlcl35O3upceXk54uPj8eabb/Lz8IiISKjiM+eRtjmz1vL/9/G6Wt9LEvDbYYPQrIlPrfVlWXZeyDpeK21zBk6fLamxvK7MABDRpSMG9O6uWj5nY2FTQWVlJX7zm98gMjISb731lug4RERkcAH+LdDExxuHfq55NOz02Qu1vu8Z8VCdZQ0A2rVrV+OI2smTJxEYGOiExIAkSejxcAg+XPuvGsvryuzu7oYeD4c4JYcoPCWqgrFjx8LX1xeLFi0SHYWIiAgAMPjx3jBJks11PD3cMahfr3of79mzJwoLC3Hw4EEAwEcffYRhw4YpmvNOwe3bIqxze7vrxfwqEk1973daDhFY2Jzs22+/xcqVK5GdnY3u3bsjMjIS7777ruhYRERkcK2aN8OjPcJtrjOgd3f4+njX+7jZbMaHH36I+Ph4dOrUCT4+PnjxxReVjlrD0wMehdlUf31p6ns/+kVF2NzGuHHjEBgYiMrKSgQGBmLixIlKx1ScJKt5AppqkWUZkp1/4RARETnD9Rs3seD9z3DjZlmtxx5o6ospr42AuwbvVbZ5+/fYsWtfnY+N/vXjiAwLVjmR8/EIm0DXrt/EkpXpOHq8SHQUIiIyIO/7vBD32CN1PvbUgF9psqwBwON9euB+b69ay4MC/NEttJOARM6n6cI2d+5cSJKEAwcOYPDgwfDx8UGbNm2wYMECAMCXX36JHj16wNvbG927d0dWVpbgxI7ZuXsfzp6/CN/77xMdhYiIDOrRyDC0at6sxrIO7drg4ZAOYgI1gJenB57o17PW8l/H9nbZs1aaLmxVRowYgccff7z6HmbTpk1DQkIC/vCHP2DatGlIS0uDLMsYMmQISktLRcdtkGvXb+K7Pbno2qUj/Fs+IDoOEREZlNlswuDHe1f/LAF45nHtF5+eEV3Q+o6/n93DO6NdQCuBiZxL09ewzZ07F4mJiVi+fDnGjx8PACgrK4O/vz+uX7+Ow4cP48EHHwQAfPPNN4iNjUV6ejqGDx+uyOsnJL+vyHaIiIiI7pY0fWyD19Xmyem7PP3009Xfe3p6omPHjqisrKwuawCqb0bLOywTERGRq9FFYXvggZqnDD08PODl5VVrGQDcvHlTsdd1pPk64qvMXcj8PgeTx8TzdCgREWnGmfMX4d/CT3QMh5RcLoWP933wcNdFpblnrv3bNZKzT4mmrEx36vaJiIhIuxw5MKSLNx0QERERGRmPsNmg9CnRa9dvInnFGnTp2A6/GRKn6LaJiIjIdfEIm4p27t6HivIKxPbpIToKERER6Yimb+vhar74agfKyivwP8/Gio5CREREOsLCpjKLxQKTjQ+tJSIiIrobCxsRERGRxvFQDxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHGsbARERERaRwLGxEREZHG/X+zG3AXBpxQrgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 802.25x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create Simon algorithm\n",
    "simon = Simon(oracle=oracle_simon, quantum_instance=quantum_instance)\n",
    "simon_circuit = simon.construct_circuit(measurement=True)\n",
    "simon_circuit.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Secret string s =  11\n"
     ]
    }
   ],
   "source": [
    "# Run the Simon algorithm to determine s, \n",
    "# where x1 XOR s = x2\n",
    "results = simon.run(quantum_instance)\n",
    "print('Secret string s = ', results['result'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
